home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 2 / Apprentice-Release2.iso / Tools / Languages / GCC 1.37.1r14 / usr / gcc-1.37.1r14 / (gcc-1.37.π) / print-tree.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-07-01  |  15.8 KB  |  674 lines  |  [TEXT/KAHL]
  1. /* Prints out tree in human readable form - GNU C-compiler
  2.    Copyright (C) 1987 Free Software Foundation, Inc.
  3.    Copyright (C) 1989, 1990 Apple Computer, Inc.
  4.  
  5. This file is part of GNU CC.
  6.  
  7. GNU CC is free software; you can redistribute it and/or modify
  8. it under the terms of the GNU General Public License as published by
  9. the Free Software Foundation; either version 1, or (at your option)
  10. any later version.
  11.  
  12. GNU CC is distributed in the hope that it will be useful,
  13. but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15. GNU General Public License for more details.
  16.  
  17. You should have received a copy of the GNU General Public License
  18. along with GNU CC; see the file COPYING.  If not, write to
  19. the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  20.  
  21.  
  22. #include "config.h"
  23. #include "tree.h"
  24. #include <stdio.h>
  25.  
  26.  
  27. /* Names of tree components.
  28.    Used for printing out the tree and error messages.  */
  29. #define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME,
  30.  
  31. char *tree_code_name[] = {
  32. #include "tree.def"
  33. };
  34. #undef DEFTREECODE
  35.  
  36. extern char *tree_code_type[];
  37. extern int tree_code_length[];
  38. extern char *mode_name[];
  39.  
  40. extern char spaces[];
  41.  
  42. #define MIN(x,y) ((x < y) ? x : y)
  43.  
  44. static FILE *outfile;
  45.  
  46. extern int tree_node_counter;
  47.  
  48. /* markvec[i] is 1 if node number i has been seen already.  */
  49.  
  50. static char *markvec;
  51.  
  52. static void dump ();
  53. void dump_tree ();
  54.  
  55. void
  56. debug_dump_tree (root)
  57.      tree root;
  58. {
  59.   dump_tree (stderr, root);
  60. }
  61.  
  62. void
  63. dump_tree (outf, root)
  64.      FILE *outf;
  65.      tree root;
  66. {
  67.   markvec = (char *) alloca (tree_node_counter + 1);
  68.   bzero (markvec, tree_node_counter + 1);
  69.   outfile = outf;
  70.   dump (root, 0);
  71.   fflush (outf);
  72. }
  73.  
  74. static
  75. void
  76. wruid (node)
  77.      tree node;
  78. {
  79.  
  80.   if (node == NULL)
  81.     fputs ("<>", outfile);
  82.   else {
  83.     fprintf (outfile, "%1d", TREE_UID (node));
  84.   }
  85. }
  86.  
  87. static 
  88. void
  89. part (title, node)
  90.      char title[];
  91.      tree node;
  92. {
  93.   fprintf (outfile, " %s = ", title);
  94.   wruid (node);
  95.   putc (';', outfile);
  96. }
  97.  
  98. /* Similar to `part' but prefix with @ if value is not constant
  99.    and print the constant value if it is constant.  */
  100. static
  101. void
  102. cpart (title, ct, punct)
  103.      char *title;
  104.      tree ct;
  105.      char punct;
  106. {
  107.   fprintf (outfile, " %s = ", title);
  108.   if (ct == NULL)
  109.     fputs ("<>", outfile);
  110.   else
  111.     {
  112.       if (!TREE_LITERAL (ct))
  113.     {
  114.       putc ('@', outfile);
  115.       wruid (ct);
  116.     }
  117.       else
  118.     fprintf (outfile, "%ld", TREE_INT_CST_LOW (ct));
  119.     }
  120.   putc (punct, outfile);
  121. }
  122.  
  123. static
  124. void
  125. walk (node, leaf, indent)
  126.      tree node;
  127.      tree leaf;
  128.      int indent;
  129. {
  130.   if (node != NULL)
  131.     dump (node, indent+1);
  132. }
  133.  
  134. static void
  135. cwalk (s, leaf, indent)
  136.      tree s;
  137.      tree leaf;
  138.      int indent;
  139. {
  140.   if (s != NULL) 
  141.     if (!TREE_LITERAL (s))
  142.       walk (s, leaf, indent);
  143. }
  144.  
  145. static void
  146. prtypeinfo (node)
  147.      register tree node;
  148. {
  149.   int first;
  150.   
  151.   part ("type", TREE_TYPE (node));
  152.   first = 1;
  153.   fputs (" [", outfile);
  154.   if (TREE_EXTERNAL (node))
  155.     {
  156.       if (!first) putc (' ', outfile);
  157.       fputs ("external", outfile);
  158.       first = 0;
  159.     }
  160.   if (TREE_PUBLIC (node))
  161.     {
  162.       if (!first) putc (' ', outfile);
  163.       fputs ("public", outfile);
  164.       first = 0;
  165.     }
  166.   if (TREE_STATIC (node))
  167.     {
  168.       if (!first) putc (' ', outfile);
  169.       fputs ("static", outfile);
  170.       first = 0;
  171.     }
  172.   if (TREE_VOLATILE (node))
  173.     {
  174.       if (!first) putc (' ', outfile);
  175.       fputs ("volatile", outfile);
  176.       first = 0;
  177.     }
  178.   if (TREE_PACKED (node))
  179.     {
  180.       if (!first) putc (' ', outfile);
  181.       fputs ("packed", outfile);
  182.       first = 0;
  183.     }
  184.   if (TREE_READONLY (node))
  185.     {
  186.       if (!first) putc (' ', outfile);
  187.       fputs ("readonly", outfile);
  188.       first = 0;
  189.     }
  190.   if (TREE_LITERAL (node))
  191.     {
  192.       if (!first) putc (' ', outfile);
  193.       fputs ("literal", outfile);
  194.       first = 0;
  195.     }
  196.   if (TREE_NONLOCAL (node))
  197.     {
  198.       if (!first) putc (' ', outfile);
  199.       fputs ("nonlocal", outfile);
  200.       first = 0;
  201.     }
  202.   if (TREE_ADDRESSABLE (node))
  203.     {
  204.       if (!first) putc (' ', outfile);
  205.       fputs ("addressable", outfile);
  206.       first = 0;
  207.     }
  208.   if (TREE_REGDECL (node))
  209.     {
  210.       if (!first) putc (' ', outfile);
  211.       fputs ("regdecl", outfile);
  212.       first = 0;
  213.     }
  214.   if (TREE_THIS_VOLATILE (node))
  215.     {
  216.       if (!first) putc (' ', outfile);
  217.       fputs ("this_vol", outfile);
  218.       first = 0;
  219.     }
  220.   if (TREE_UNSIGNED (node))
  221.     {
  222.       if (!first) putc (' ', outfile);
  223.       fputs ("unsigned", outfile);
  224.       first = 0;
  225.     }
  226.   if (TREE_ASM_WRITTEN (node))
  227.     {
  228.       if (!first) putc (' ', outfile);
  229.       fputs ("asm_written", outfile);
  230.       first = 0;
  231.     }
  232.   if (TREE_INLINE (node))
  233.     {
  234.       if (!first) putc (' ', outfile);
  235.       fputs ("inline", outfile);
  236.       first = 0;
  237.     }
  238.   if (TREE_USED (node))
  239.     {
  240.       if (!first) putc (' ', outfile);
  241.       fputs ("used", outfile);
  242.       first = 0;
  243.     }
  244.   if (TREE_PERMANENT (node))
  245.     {
  246.       if (!first) putc (' ', outfile);
  247.       fputs ("permanent", outfile);
  248.       first = 0;
  249.     }
  250.   if (TREE_LANG_FLAG_1 (node))
  251.     {
  252.       if (!first) putc (' ', outfile);
  253.       fputs ("lang_flag_1", outfile);
  254.       first = 0;
  255.     }
  256.   if (TREE_LANG_FLAG_2 (node))
  257.     {
  258.       if (!first) putc (' ', outfile);
  259.       fputs ("lang_flag_2", outfile);
  260.       first = 0;
  261.     }
  262.   if (TREE_LANG_FLAG_3 (node))
  263.     {
  264.       if (!first) putc (' ', outfile);
  265.       fputs ("lang_flag_3", outfile);
  266.       first = 0;
  267.     }
  268.   if (TREE_LANG_FLAG_4 (node))
  269.     {
  270.       if (!first) putc (' ', outfile);
  271.       fputs ("lang_flag_4", outfile);
  272.       first = 0;
  273.     }
  274. #ifdef APPLE_C
  275.   /* Recognize and print declarations of pascal and direct functions. */
  276.   if (TREE_PASCAL (node))
  277.     {
  278.       if (!first) putc (' ', outfile);
  279.       fputs ("pascal", outfile);
  280.       first = 0;
  281.     }
  282.   if (TREE_DIRECT (node))
  283.     {
  284.       if (!first) putc (' ', outfile);
  285.       fputs ("direct", outfile);
  286.       first = 0;
  287.     }
  288. #endif /* APPLE_C */
  289.   fputs ("] ", outfile);
  290. }
  291.  
  292. static void
  293. prdeclmodeinfo (node)
  294.      tree node;
  295. {
  296.   register enum machine_mode mode = DECL_MODE (node);
  297.   fprintf (outfile, " %s;", mode_name[(int) mode]);
  298.  
  299.   cpart ("size", DECL_SIZE (node), '*');
  300.   fprintf (outfile, "%d;", DECL_SIZE_UNIT (node));
  301.  
  302.   fprintf (outfile, " alignment = %1d;", DECL_ALIGN (node));
  303. }
  304.  
  305. static
  306. void
  307. prtypemodeinfo (node)
  308.      tree node;
  309. {
  310.   register enum machine_mode mode = TYPE_MODE (node);
  311.   fprintf (outfile, " %s;", mode_name[(int) mode]);
  312.  
  313.   cpart ("size", TYPE_SIZE (node), '*');
  314.   fprintf (outfile, "%d;", TYPE_SIZE_UNIT (node));
  315.  
  316.   fprintf (outfile, " alignment = %1d;", TYPE_ALIGN (node));
  317. }
  318.  
  319. static
  320. void
  321. skip (indent)
  322.      int indent;
  323. {
  324.   putc ('\n',outfile);
  325.   fputs (spaces + (strlen (spaces) - (12 + MIN (40,(indent+1)*2))), outfile);
  326. }
  327.  
  328. /* Output a description of the tree node NODE
  329.    if its description has not been output already.  */
  330.  
  331. static 
  332. void
  333. dump (node, indent)
  334.      tree node;
  335.      int indent;
  336. {
  337.   register enum tree_code code = TREE_CODE (node);
  338.   register int i;
  339.   register int len, first_rtl;
  340.   int nochain = 0;
  341.  
  342.   if (markvec[TREE_UID (node)])
  343.     return;
  344.   markvec[TREE_UID (node)] = 1;
  345.  
  346.   fputs ("   ", outfile);
  347.   fprintf (outfile, "%5d", TREE_UID (node));
  348.   fputs (spaces + (strlen (spaces) - MIN (40, (indent+1)*2)), outfile);
  349.   fputs (tree_code_name[(int) code], outfile);
  350.  
  351.   switch (*tree_code_type[(int) code])
  352.     {
  353.     case 'd':
  354.       fputs (" name = ", outfile);
  355.       if (DECL_NAME (node) == NULL)
  356.     fputs ("<>;", outfile);
  357.       else
  358.     fprintf (outfile, "%s;",
  359.          IDENTIFIER_POINTER (DECL_NAME (node)));
  360.       fprintf (outfile, " at %s line %d;",
  361.            DECL_SOURCE_FILE (node), DECL_SOURCE_LINE (node));
  362.       skip (indent);
  363.       prdeclmodeinfo (node);
  364.       prtypeinfo (node);
  365. #ifdef PRINT_LANG_DECL
  366.       print_lang_decl (node);
  367. #endif
  368.       skip (indent);
  369.       fprintf (outfile, " offset = %1d;", DECL_OFFSET (node));
  370.       if (DECL_VOFFSET (node) != NULL)
  371.     {
  372.       fputs ("voffset = ", outfile);
  373.       wruid (DECL_VOFFSET (node));
  374.       fprintf (outfile, "*%1d;", DECL_VOFFSET_UNIT (node));
  375.     }
  376.       part ("context", DECL_CONTEXT (node));
  377.       if (DECL_ARGUMENTS (node) || DECL_RESULT (node)
  378.       || DECL_INITIAL (node))
  379.     {
  380.       skip (indent);
  381.       part ("arguments", DECL_ARGUMENTS (node));
  382.       part ("result", DECL_RESULT (node));
  383.       if ((int) (DECL_INITIAL (node)) == 1)
  384.         fprintf (outfile, " initial = const 1;");
  385.       else
  386.         part ("initial", DECL_INITIAL (node));
  387.     }
  388. #ifdef PRINT_LANG_DECL
  389.       walk_lang_decl (node);
  390. #endif
  391.       part ("chain", TREE_CHAIN (node));
  392.       /* A Decl's chain contents is not part of the decl.  */
  393.       nochain = 1;
  394.       fputc ('\n', outfile);
  395.       cwalk (DECL_SIZE (node), node, indent);
  396.       walk (TREE_TYPE (node), node, indent);
  397.       walk (DECL_VOFFSET (node), node, indent);
  398.       walk (DECL_CONTEXT (node), node, indent);
  399.       walk (DECL_ARGUMENTS (node), node, indent);
  400.       walk (DECL_RESULT (node), node, indent);
  401.       if ((int) (DECL_INITIAL (node)) != 1)
  402.     walk (DECL_INITIAL (node), node, indent);
  403.       break;
  404.  
  405.     case 't':
  406.       if (TYPE_NAME (node) != NULL)
  407.     {
  408.       if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE)
  409.         fprintf (outfile, " type name = %s;",
  410.              IDENTIFIER_POINTER (TYPE_NAME (node)));
  411.       else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL
  412.            && DECL_NAME (TYPE_NAME (node)) != NULL)
  413.         fprintf (outfile, " type name = %s;",
  414.              IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (node))));
  415.     }
  416.       prtypemodeinfo (node);
  417.       prtypeinfo (node);
  418. #ifdef PRINT_LANG_TYPE
  419.       print_lang_type (node);
  420. #endif
  421.       skip (indent);
  422.       part ("pointers_to_this", TYPE_POINTER_TO (node));
  423.       if (code == ARRAY_TYPE || code == SET_TYPE)
  424.     {
  425.       part ("domain", TYPE_DOMAIN (node));
  426.       cpart ("separation", TYPE_SEP (node), '*');
  427.       fprintf (outfile, "%d;", TYPE_SEP_UNIT (node));
  428.     }
  429.       else if (code == INTEGER_TYPE)
  430.     {
  431.       cpart ("min", TYPE_MIN_VALUE (node), ';');
  432.       cpart ("max", TYPE_MAX_VALUE (node), ';');
  433.       fprintf (outfile, "precision = %d;", TYPE_PRECISION (node));
  434.     }
  435.       else if (code == ENUMERAL_TYPE)
  436.     {
  437.       cpart ("min", TYPE_MIN_VALUE (node), ';');
  438.       cpart ("max", TYPE_MAX_VALUE (node), ';');
  439.       part ("values", TYPE_VALUES (node));
  440.       fprintf (outfile, "precision = %d;", TYPE_PRECISION (node));
  441.     }
  442.       else if (code == REAL_TYPE)
  443.     {
  444.       fprintf (outfile, "precision = %d;", TYPE_PRECISION (node));
  445.     }
  446.       else if (code == RECORD_TYPE
  447.            || code == UNION_TYPE)
  448.     {
  449.       part ("fields", TYPE_FIELDS (node));
  450.     }
  451.       else if (code == FUNCTION_TYPE)
  452.     {
  453.       part ("arg_types", TYPE_ARG_TYPES (node));
  454.     }
  455.       else if (code == METHOD_TYPE)
  456.     {
  457.       part ("arg_types", TYPE_ARG_TYPES (node));
  458.     }
  459. #ifdef PRINT_LANG_TYPE
  460.       walk_lang_type (node);
  461. #endif
  462.       part ("chain", TREE_CHAIN (node));
  463.       /* A type's chain's contents are not printed because the chain of types
  464.      is not part of the meaning of any particular type.  */
  465.       nochain = 1;
  466.       fputc ('\n', outfile);
  467.       cwalk (TYPE_SIZE (node), node, indent);
  468.       walk (TREE_TYPE (node), node, indent);
  469.       walk (TYPE_VALUES (node), node, indent);
  470.       walk (TYPE_SEP (node), node, indent);
  471.       walk (TYPE_POINTER_TO (node), node, indent);
  472.       break;
  473.  
  474.     case 'e':
  475.     case 'r':
  476.       prtypeinfo (node);
  477.       fputs (" ops =", outfile);
  478.       first_rtl = len = tree_code_length[(int) code];
  479.       /* These kinds of nodes contain rtx's, not trees,
  480.      after a certain point.  Print the rtx's as rtx's.  */
  481.       switch (code)
  482.     {
  483.     case SAVE_EXPR:
  484.       first_rtl = 1;
  485.       break;
  486.     case CALL_EXPR:
  487.       first_rtl = 2;
  488.       break;
  489.     case METHOD_CALL_EXPR:
  490.       first_rtl = 3;
  491.       break;
  492.     case WITH_CLEANUP_EXPR:
  493.       /* Should be defined to be 2.  */
  494.       first_rtl = 1;
  495.       break;
  496.     case RTL_EXPR:
  497.       first_rtl = 0;
  498.     }
  499.       for (i = 0; i < len; i++)
  500.     {
  501.       if (i >= first_rtl)
  502.         {
  503.           skip (indent);
  504.           if (TREE_OPERAND (node, i))
  505.         print_rtl (outfile, TREE_OPERAND (node, i));
  506.           else
  507.         fprintf (outfile, "(nil)");
  508.           fprintf (outfile, "\n");
  509.         }
  510.       else
  511.         {
  512.           fputs (" ", outfile);
  513.           wruid (TREE_OPERAND (node, i));
  514.           fputs (";", outfile);
  515.         }
  516.     }
  517.       part ("chain", TREE_CHAIN (node));
  518.       fputc ('\n', outfile);
  519.       walk (TREE_TYPE (node), node, indent);
  520.       for (i = 0; i < len && i < first_rtl; i++)
  521.     walk (TREE_OPERAND (node, i), node, indent);
  522.       break;
  523.  
  524.     case 's':
  525.       prtypeinfo (node);
  526.       fprintf (outfile, " at %s line %d;",
  527.            STMT_SOURCE_FILE (node), STMT_SOURCE_LINE (node));
  528.       switch (TREE_CODE (node))
  529.     {
  530.     case IF_STMT:
  531.       part ("cond", STMT_COND (node));
  532.       part ("then", STMT_THEN (node));
  533.       part ("else", STMT_ELSE (node));
  534.       break;
  535.  
  536.     case LET_STMT:
  537.     case WITH_STMT:
  538.       part ("vars", STMT_VARS (node));
  539.       part ("tags", STMT_TYPE_TAGS (node));
  540.       part ("supercontext", STMT_SUPERCONTEXT (node));
  541.       part ("bind_size", STMT_BIND_SIZE (node));
  542.       part ("body", STMT_BODY (node));
  543.       part ("subblocks", STMT_SUBBLOCKS (node));
  544.       break;
  545.  
  546.     case CASE_STMT:
  547.       part ("case_index", STMT_CASE_INDEX (node));
  548.       part ("case_list", STMT_CASE_LIST (node));
  549.       break;
  550.  
  551.     default:
  552.       part ("body", STMT_BODY (node));
  553.       break;
  554.     }
  555.       part ("chain", TREE_CHAIN (node));
  556.       fputc ('\n', outfile);
  557.       walk (TREE_TYPE (node), node, indent);
  558.       switch (TREE_CODE (node))
  559.     {
  560.     case IF_STMT:
  561.       walk (STMT_COND (node), node, indent);
  562.       walk (STMT_THEN (node), node, indent);
  563.       walk (STMT_ELSE (node), node, indent);
  564.       break;
  565.  
  566.     case LET_STMT:
  567.     case WITH_STMT:
  568.       walk (STMT_VARS (node), node, indent);
  569.       walk (STMT_TYPE_TAGS (node), node, indent);
  570.       walk (STMT_SUPERCONTEXT (node), node, indent);
  571.       walk (STMT_BIND_SIZE (node), node, indent);
  572.       walk (STMT_BODY (node), node, indent);
  573.       walk (STMT_SUBBLOCKS (node), node, indent);
  574.       break;
  575.  
  576.     case CASE_STMT:
  577.       walk (STMT_CASE_INDEX (node), node, indent);
  578.       walk (STMT_CASE_LIST (node), node, indent);
  579.       break;
  580.  
  581.     default:
  582.       walk (STMT_BODY (node), node, indent);
  583.       break;
  584.     }
  585.       break;
  586.  
  587.     case 'c':
  588.       switch (code)
  589.     {
  590.     case INTEGER_CST:
  591.       if (TREE_INT_CST_HIGH (node) == 0)
  592.         fprintf (outfile, " = %1u;", TREE_INT_CST_LOW (node));
  593.       else if (TREE_INT_CST_HIGH (node) == -1
  594.            && TREE_INT_CST_LOW (node) != 0)
  595.         fprintf (outfile, " = -%1u;", -TREE_INT_CST_LOW (node));
  596.       else
  597.         fprintf (outfile, " = 0x%x%08x;",
  598.              TREE_INT_CST_HIGH (node),
  599.              TREE_INT_CST_LOW (node));
  600.       break;
  601.  
  602.     case REAL_CST:
  603. #ifndef REAL_IS_NOT_DOUBLE
  604.       fprintf (outfile, " = %e;", TREE_REAL_CST (node));
  605. #else
  606.       {
  607.         int i;
  608.         char *p = (char *) &TREE_REAL_CST (node);
  609.         fprintf (outfile, " = 0x");
  610.         for (i = 0; i < sizeof TREE_REAL_CST (node); i++)
  611.           fprintf (outfile, "%02x", *p++);
  612.         fprintf (outfile, ";");
  613.       }
  614. #endif /* REAL_IS_NOT_DOUBLE */
  615.       break;
  616.  
  617.     case COMPLEX_CST:
  618.       part ("realpart", TREE_REALPART (node));
  619.       part ("imagpart", TREE_IMAGPART (node));
  620.       walk (TREE_REALPART (node), node, indent);
  621.       walk (TREE_IMAGPART (node), node, indent);
  622.       break;
  623.  
  624.     case STRING_CST:
  625.       fprintf (outfile, " = \"%s\";", TREE_STRING_POINTER (node));
  626.     }
  627.       prtypeinfo (node);
  628.       part ("chain", TREE_CHAIN (node));
  629.       fputc ('\n', outfile);
  630.       walk (TREE_TYPE (node), node, indent);
  631.       break;
  632.  
  633.     case 'x':
  634.       if (code == IDENTIFIER_NODE)
  635.     {
  636.       fprintf (outfile, " = %s;\n", IDENTIFIER_POINTER (node));
  637.       nochain = 1;
  638.     }
  639.       else if (code == TREE_LIST)
  640.     {
  641.       prtypeinfo (node);
  642.       part ("purpose", TREE_PURPOSE (node));
  643.       part ("value", TREE_VALUE (node));
  644.       part ("chain", TREE_CHAIN (node));
  645.       fputc ('\n', outfile);
  646.       walk (TREE_TYPE (node), node, indent);
  647.       walk (TREE_PURPOSE (node), node, indent);
  648.       walk (TREE_VALUE (node), node, indent);
  649.     }
  650.       else if (code == OP_IDENTIFIER)
  651.     {
  652.       prtypeinfo (node);
  653.       part ("op1", TREE_PURPOSE (node));
  654.       part ("op2", TREE_VALUE (node));
  655.       part ("chain", TREE_CHAIN (node));
  656.       fputc ('\n', outfile);
  657.       walk (TREE_TYPE (node), node, indent);
  658.       walk (TREE_PURPOSE (node), node, indent);
  659.       walk (TREE_VALUE (node), node, indent);
  660.     }
  661.       else if (code == ERROR_MARK)
  662.     fputc ('\n', outfile);
  663.       else abort ();
  664.  
  665.       break;
  666.  
  667.     default:
  668.       abort ();
  669.     } /* switch */
  670.  
  671.   if (TREE_CHAIN (node) != NULL && ! nochain)
  672.     dump (TREE_CHAIN (node), indent);
  673. }
  674.